Preslikani tipi v TypeScriptu za dinamične transformacije objektov: Celovit vodnik

TypeScript s svojim močnim poudarkom na statičnem tipkanju omogoča razvijalcem pisanje zanesljivejše in lažje vzdržljive kode. Ključna značilnost, ki k temu bistveno prispeva, so preslikani tipi. Ta vodnik se poglablja v svet preslikanih tipov v TypeScriptu in ponuja celovito razumevanje njihove funkcionalnosti, prednosti in praktične uporabe, zlasti v kontekstu razvoja globalnih programskih rešitev.

Razumevanje temeljnih konceptov

V svojem bistvu preslikani tip omogoča ustvarjanje novega tipa na podlagi lastnosti obstoječega tipa. Nov tip definirate z iteracijo po ključih drugega tipa in uporabo transformacij na vrednostih. To je izjemno uporabno v primerih, ko morate dinamično spreminjati strukturo objektov, na primer spreminjanje podatkovnih tipov lastnosti, spreminjanje lastnosti v neobvezne ali dodajanje novih lastnosti na podlagi obstoječih.

Začnimo z osnovami. Poglejmo si preprost vmesnik:

            interface Person {
  name: string;
  age: number;
  email: string;
}
            

              
                Copy
              
            
          

Sedaj definirajmo preslikani tip, ki vse lastnosti vmesnika Person spremeni v neobvezne:

            type OptionalPerson = { 
  [K in keyof Person]?: Person[K];
};

            

              
                Copy
              
            
          

V tem primeru:

• [K in keyof Person] iterira skozi vsak ključ (name, age, email) vmesnika Person.
• ? naredi vsako lastnost neobvezno.
• Person[K] se nanaša na tip lastnosti v originalnem vmesniku Person.

Rezultat, tip OptionalPerson, je dejansko videti takole:

            {
  name?: string;
  age?: number;
  email?: string;
}
            

              
                Copy
              
            
          

To prikazuje moč preslikanih tipov za dinamično spreminjanje obstoječih tipov.

Sintaksa in struktura preslikanih tipov

Sintaksa preslikanega tipa je precej specifična in sledi tej splošni strukturi:

            type NewType = { 
  [Key in KeysType]: ValueType;
};
            

              
                Copy
              
            
          

Poglejmo si vsako komponento posebej:

• NewType: Ime, ki ga dodelite novemu tipu, ki ga ustvarjate.
• [Key in KeysType]: To je jedro preslikanega tipa. Key je spremenljivka, ki iterira skozi vsak element KeysType. KeysType je pogosto, vendar ne vedno, keyof drugega tipa (kot v našem primeru OptionalPerson). Lahko je tudi unija nizovnih literalov ali bolj kompleksen tip.
• ValueType: Določa tip lastnosti v novem tipu. Lahko je neposreden tip (kot string), tip, ki temelji na lastnosti originalnega tipa (kot Person[K]), ali bolj kompleksna transformacija originalnega tipa.

Primer: Transformacija tipov lastnosti

Predstavljajte si, da morate vse številske lastnosti objekta pretvoriti v nize. To lahko storite s preslikanim tipom:

            interface Product {
  id: number;
  name: string;
  price: number;
  quantity: number;
}

type StringifiedProduct = {
  [K in keyof Product]: Product[K] extends number ? string : Product[K];
};

            

              
                Copy
              
            
          

V tem primeru:

• Iteriramo skozi vsak ključ vmesnika Product.
• Uporabljamo pogojni tip (Product[K] extends number ? string : Product[K]) za preverjanje, ali je lastnost število.
• Če je število, nastavimo tip lastnosti na string; sicer ohranimo originalni tip.

Rezultat, tip StringifiedProduct, bi bil:

            {
  id: string;
  name: string;
  price: string;
  quantity: string;
}
            

              
                Copy
              
            
          

Ključne značilnosti in tehnike

1. Uporaba keyof in indeksnih podpisov

Kot je bilo že prikazano, je keyof temeljno orodje za delo s preslikanimi tipi. Omogoča iteracijo po ključih tipa. Indeksni podpisi pa omogočajo definiranje tipa lastnosti, ko ključev ne poznamo vnaprej, a jih vseeno želimo transformirati.

Primer: Transformacija vseh lastnosti na podlagi indeksnega podpisa

            interface StringMap {
  [key: string]: number;
}

type StringMapToString = {
  [K in keyof StringMap]: string;
};

            

              
                Copy
              
            
          

Tukaj so vse številske vrednosti v `StringMap` pretvorjene v nize znotraj novega tipa.

2. Pogojni tipi znotraj preslikanih tipov

Pogojni tipi so močna značilnost TypeScripta, ki omogoča izražanje odnosov med tipi na podlagi pogojev. V kombinaciji s preslikanimi tipi omogočajo zelo sofisticirane transformacije.

Primer: Odstranjevanje `null` in `undefined` iz tipa

            type NonNullableProperties = {
  [K in keyof T]: T[K] extends (null | undefined) ? never : T[K];
};

            

              
                Copy
              
            
          

Ta preslikani tip iterira skozi vse ključe tipa T in uporablja pogojni tip za preverjanje, ali vrednost dovoljuje `null` ali `undefined`. Če dovoljuje, se tip ovrednoti kot `never`, kar dejansko odstrani to lastnost; sicer ohrani originalni tip. Ta pristop naredi tipe bolj robustne z izključevanjem potencialno problematičnih vrednosti `null` ali `undefined`, izboljšuje kakovost kode in je v skladu z najboljšimi praksami za globalni razvoj programske opreme.

3. Pomožni tipi za učinkovitost

TypeScript ponuja vgrajene pomožne tipe, ki poenostavljajo pogoste naloge manipulacije s tipi. Ti tipi v ozadju uporabljajo preslikane tipe.

• Partial: Vse lastnosti tipa T naredi neobvezne (kot je prikazano v prejšnjem primeru).
• Required: Vse lastnosti tipa T naredi obvezne.
• Readonly: Vse lastnosti tipa T naredi samo za branje.
• Pick: Ustvari nov tip, ki vsebuje samo določene ključe (K) iz tipa T.
• Omit: Ustvari nov tip, ki vsebuje vse lastnosti tipa T razen določenih ključev (K).

Primer: Uporaba Pick in Omit

            interface User {
  id: number;
  name: string;
  email: string;
  role: string;
}

type UserSummary = Pick;
// { id: number; name: string; }

type UserWithoutEmail = Omit;
// { id: number; name: string; role: string; }
            

              
                Copy
              
            
          

Ti pomožni tipi vam prihranijo pisanje ponavljajočih se definicij preslikanih tipov in izboljšajo berljivost kode. Še posebej so uporabni pri globalnem razvoju za upravljanje različnih pogledov ali ravni dostopa do podatkov na podlagi uporabnikovih dovoljenj ali konteksta aplikacije.

Praktične uporabe in primeri

1. Validacija in transformacija podatkov

Preslikani tipi so neprecenljivi za validacijo in transformacijo podatkov, prejetih iz zunanjih virov (API-ji, baze podatkov, uporabniški vnosi). To je ključnega pomena v globalnih aplikacijah, kjer se lahko srečujete s podatki iz različnih virov in morate zagotoviti celovitost podatkov. Omogočajo vam definiranje specifičnih pravil, kot je validacija podatkovnih tipov, in samodejno spreminjanje podatkovnih struktur na podlagi teh pravil.

Primer: Pretvorba odgovora API-ja

            interface ApiResponse {
  userId: string;
  id: string;
  title: string;
  completed: boolean;
}

type CleanedApiResponse = {
  [K in keyof ApiResponse]:
    K extends 'userId' | 'id' ? number :
    K extends 'title' ? string :
    K extends 'completed' ? boolean : any;
};

            

              
                Copy
              
            
          

Ta primer pretvori lastnosti userId in id (prvotno nizi iz API-ja) v števila. Lastnost title je pravilno tipizirana kot niz, completed pa ostane logična vrednost. To zagotavlja doslednost podatkov in preprečuje morebitne napake pri nadaljnji obdelavi.

2. Ustvarjanje ponovno uporabljivih lastnosti (props) komponent

V ogrodjih, kot sta React in druga, lahko preslikani tipi poenostavijo ustvarjanje ponovno uporabljivih lastnosti komponent. To je še posebej pomembno pri razvoju globalnih UI komponent, ki se morajo prilagajati različnim lokalizacijam in uporabniškim vmesnikom.

Primer: Obravnavanje lokalizacije

            interface TextProps {
  textId: string;
  defaultText: string;
  locale: string;
}

type LocalizedTextProps = {
  [K in keyof TextProps as `localized-${K}`]: TextProps[K];
};

            

              
                Copy
              
            
          

V tej kodi nov tip `LocalizedTextProps` doda predpono vsakemu imenu lastnosti iz `TextProps`. Na primer, `textId` postane `localized-textId`, kar je uporabno za nastavljanje lastnosti komponent. Ta vzorec bi se lahko uporabil za generiranje lastnosti, ki omogočajo dinamično spreminjanje besedila glede na lokalizacijo uporabnika. To je bistveno za gradnjo večjezičnih uporabniških vmesnikov, ki delujejo brezhibno v različnih regijah in jezikih, na primer v e-trgovinskih aplikacijah ali mednarodnih družbenih omrežjih. Transformirane lastnosti razvijalcu omogočajo večji nadzor nad lokalizacijo in možnost ustvarjanja dosledne uporabniške izkušnje po vsem svetu.

3. Dinamično generiranje obrazcev

Preslikani tipi so uporabni za dinamično generiranje polj obrazca na podlagi podatkovnih modelov. V globalnih aplikacijah je to lahko koristno za ustvarjanje obrazcev, ki se prilagajajo različnim vlogam uporabnikov ali podatkovnim zahtevam.

Primer: Samodejno generiranje polj obrazca na podlagi ključev objekta

            interface UserProfile {
  firstName: string;
  lastName: string;
  email: string;
  phoneNumber: string;
}

type FormFields = {
  [K in keyof UserProfile]: {
    label: string;
    type: string;
    required: boolean;
  };
};

            

              
                Copy
              
            
          

To vam omogoča, da definirate strukturo obrazca na podlagi lastnosti vmesnika UserProfile. S tem se izognete ročnemu definiranju polj obrazca, kar izboljša prilagodljivost in vzdržljivost vaše aplikacije.

Napredne tehnike preslikanih tipov

1. Preimenovanje ključev (Key Remapping)

TypeScript 4.1 je uvedel preimenovanje ključev v preslikanih tipih. To omogoča preimenovanje ključev med transformacijo tipa. To je še posebej uporabno pri prilagajanju tipov različnim zahtevam API-jev ali kadar želite ustvariti bolj uporabniku prijazna imena lastnosti.

Primer: Preimenovanje lastnosti

            interface Product {
  productId: number;
  productName: string;
  productDescription: string;
  price: number;
}

type ProductDto = {
  [K in keyof Product as `dto_${K}`]: Product[K];
};

            

              
                Copy
              
            
          

To vsako lastnost tipa Product preimenuje tako, da se začne s predpono dto_. To je dragoceno pri preslikovanju med podatkovnimi modeli in API-ji, ki uporabljajo drugačno konvencijo poimenovanja. Pomembno je pri mednarodnem razvoju programske opreme, kjer se aplikacije povezujejo z več zalednimi sistemi, ki imajo lahko specifične konvencije poimenovanja, kar omogoča gladko integracijo.

2. Pogojno preimenovanje ključev

Preimenovanje ključev lahko kombinirate s pogojnimi tipi za bolj kompleksne transformacije, kar vam omogoča preimenovanje ali izključitev lastnosti na podlagi določenih kriterijev. Ta tehnika omogoča sofisticirane transformacije.

Primer: Izključevanje lastnosti iz DTO-ja

            
interface Product {
    id: number;
    name: string;
    description: string;
    price: number;
    category: string;
    isActive: boolean;
}

type ProductDto = {
    [K in keyof Product as K extends 'description' | 'isActive' ? never : K]: Product[K]
}

            

              
                Copy
              
            
          

Tukaj sta lastnosti description in isActive dejansko odstranjeni iz generiranega tipa ProductDto, ker se ključ razreši v never, če je lastnost 'description' ali 'isActive'. To omogoča ustvarjanje specifičnih objektov za prenos podatkov (DTO), ki vsebujejo samo potrebne podatke za različne operacije. Tak selektiven prenos podatkov je ključen za optimizacijo in zasebnost v globalni aplikaciji. Omejitve prenosa podatkov zagotavljajo, da se po omrežjih pošiljajo samo relevantni podatki, kar zmanjšuje porabo pasovne širine in izboljšuje uporabniško izkušnjo. To je v skladu z globalnimi predpisi o zasebnosti.

3. Uporaba preslikanih tipov z generiki

Preslikane tipe je mogoče kombinirati z generiki za ustvarjanje zelo prilagodljivih in ponovno uporabnih definicij tipov. To vam omogoča pisanje kode, ki lahko obravnava različne tipe, kar močno poveča ponovno uporabnost in vzdržljivost vaše kode, kar je še posebej dragoceno v velikih projektih in mednarodnih ekipah.

Primer: Generična funkcija za transformacijo lastnosti objekta

            
function transformObjectValues(obj: T, transform: (value: T[K]) => U): {
    [P in keyof T]: U;
} {
    const result: any = {};
    for (const key in obj) {
        if (obj.hasOwnProperty(key)) {
            result[key] = transform(obj[key]);
        }
    }
    return result;
}

interface Order {
    id: number;
    items: string[];
    total: number;
}

const order: Order = {
    id: 123,
    items: ['apple', 'banana'],
    total: 5.99,
};

const stringifiedOrder = transformObjectValues(order, (value) => String(value));
// stringifiedOrder: { id: string; items: string; total: string; }

            

              
                Copy
              
            
          

V tem primeru funkcija transformObjectValues uporablja generike (T, K in U), da sprejme objekt (obj) tipa T in transformacijsko funkcijo, ki sprejme eno lastnost iz T in vrne vrednost tipa U. Funkcija nato vrne nov objekt, ki vsebuje iste ključe kot originalni objekt, vendar z vrednostmi, ki so bile transformirane v tip U.

Najboljše prakse in premisleki

1. Varnost tipov in vzdržljivost kode

Ena največjih prednosti TypeScripta in preslikanih tipov je povečana varnost tipov. By definiranjem jasnih tipov napake odkrijete že med razvojem, kar zmanjšuje verjetnost napak med izvajanjem. Koda postane lažja za razumevanje in preoblikovanje, zlasti v velikih projektih. Poleg tega uporaba preslikanih tipov zagotavlja, da je koda manj nagnjena k napakam, ko se programska oprema širi in prilagaja potrebam milijonov uporabnikov po vsem svetu.

2. Berljivost in slog kode

Čeprav so preslikani tipi lahko močni, je bistveno, da jih pišete na jasen in berljiv način. Uporabljajte smiselna imena spremenljivk in komentirajte kodo, da pojasnite namen kompleksnih transformacij. Jasnost kode zagotavlja, da jo lahko razvijalci z različnimi ozadji berejo in razumejo. Doslednost pri slogu, konvencijah poimenovanja in oblikovanju naredi kodo bolj dostopno in prispeva k bolj tekočemu razvojnemu procesu, zlasti v mednarodnih ekipah, kjer različni člani delajo na različnih delih programske opreme.

3. Pretirana uporaba in kompleksnost

Izogibajte se pretirani uporabi preslikanih tipov. Čeprav so močni, lahko naredijo kodo manj berljivo, če se uporabljajo prekomerno ali ko so na voljo enostavnejše rešitve. Premislite, ali bi bila bolj primerna rešitev neposredna definicija vmesnika ali preprosta pomožna funkcija. Če vaši tipi postanejo preveč kompleksni, jih je lahko težko razumeti in vzdrževati. Vedno upoštevajte ravnotežje med varnostjo tipov in berljivostjo kode. Vzpostavitev tega ravnotežja zagotavlja, da lahko vsi člani mednarodne ekipe učinkovito berejo, razumejo in vzdržujejo kodo.

4. Zmogljivost

Preslikani tipi vplivajo predvsem na preverjanje tipov med prevajanjem in običajno ne povzročajo znatnih obremenitev med izvajanjem. Vendar pa bi lahko preveč kompleksne manipulacije s tipi upočasnile proces prevajanja. Zmanjšajte kompleksnost in upoštevajte vpliv na čas gradnje, zlasti v velikih projektih ali za ekipe, razpršene po različnih časovnih pasovih in z različnimi omejitvami virov.

Zaključek

Preslikani tipi v TypeScriptu ponujajo močan nabor orodij za dinamično transformacijo oblik objektov. So neprecenljivi za gradnjo varne, vzdržljive in ponovno uporabne kode, zlasti pri delu s kompleksnimi podatkovnimi modeli, interakcijami z API-ji in razvojem UI komponent. Z obvladovanjem preslikanih tipov lahko pišete bolj robustne in prilagodljive aplikacije ter ustvarjate boljšo programsko opremo za globalni trg. Za mednarodne ekipe in globalne projekte uporaba preslikanih tipov ponuja robustno kakovost kode in vzdržljivost. Tukaj obravnavane značilnosti so ključne za gradnjo prilagodljive in razširljive programske opreme, izboljšanje vzdržljivosti kode in ustvarjanje boljših izkušenj za uporabnike po vsem svetu. Preslikani tipi olajšajo posodabljanje kode, ko se dodajo ali spremenijo nove funkcije, API-ji ali podatkovni modeli.